home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 242 / Issue 242 - April 2008 - DPCS0408DVD.ISO / Software Money Savers / VirtualDub / Source / VirtualDub-1.7.7-src.7z / src / h / vd2 / plugin / vdinputdriver.h < prev    next >
Encoding:
C/C++ Source or Header  |  2007-09-29  |  9.1 KB  |  298 lines
  1. //    VirtualDub - Video processing and capture application
  2. //    Plugin headers
  3. //    Copyright (C) 1998-2007 Avery Lee, All Rights Reserved.
  4. //
  5. //    The plugin headers in the VirtualDub plugin SDK are licensed differently
  6. //    differently than VirtualDub and the Plugin SDK themselves.  This
  7. //    particular file is thus licensed as follows (the "zlib" license):
  8. //
  9. //    This software is provided 'as-is', without any express or implied
  10. //    warranty.  In no event will the authors be held liable for any
  11. //    damages arising from the use of this software.
  12. //
  13. //    Permission is granted to anyone to use this software for any purpose,
  14. //    including commercial applications, and to alter it and redistribute it
  15. //    freely, subject to the following restrictions:
  16. //
  17. //    1.    The origin of this software must not be misrepresented; you must
  18. //        not claim that you wrote the original software. If you use this
  19. //        software in a product, an acknowledgment in the product
  20. //        documentation would be appreciated but is not required.
  21. //    2.    Altered source versions must be plainly marked as such, and must
  22. //        not be misrepresented as being the original software.
  23. //    3.    This notice may not be removed or altered from any source
  24. //        distribution.
  25.  
  26. #ifndef f_VD2_PLUGIN_VDINPUTDRIVER_H
  27. #define f_VD2_PLUGIN_VDINPUTDRIVER_H
  28.  
  29. #include "vdplugin.h"
  30.  
  31. /// Unsigned 32-bit fraction.
  32. struct VDXFraction {
  33.     uint32 mNumerator;
  34.     uint32 mDenominator;
  35. };
  36.  
  37. struct VDXPixmap {
  38.     void            *data;
  39.     const uint32    *palette;
  40.     sint32            w;
  41.     sint32            h;
  42.     ptrdiff_t        pitch;
  43.     sint32            format;
  44.  
  45.     // Auxiliary planes are always byte-per-pixel.
  46.     void            *data2;        // Cb (U) for YCbCr
  47.     ptrdiff_t        pitch2;
  48.     void            *data3;        // Cr (V) for YCbCr
  49.     ptrdiff_t        pitch3;
  50. };
  51.  
  52. namespace nsVDXPixmap {
  53.     enum VDXPixmapFormat {
  54.         kPixFormat_Null                = 0,
  55.         kPixFormat_XRGB1555            = 5,
  56.         kPixFormat_RGB565            = 6,
  57.         kPixFormat_RGB888            = 7,
  58.         kPixFormat_XRGB8888            = 8,
  59.         kPixFormat_Y8                = 9,
  60.         kPixFormat_YUV422_UYVY        = 10,
  61.         kPixFormat_YUV422_YUYV        = 11,
  62.         kPixFormat_YUV444_Planar    = 13,
  63.         kPixFormat_YUV422_Planar    = 14,
  64.         kPixFormat_YUV420_Planar    = 15,
  65.         kPixFormat_YUV411_Planar    = 16,
  66.         kPixFormat_YUV410_Planar    = 17
  67.     };
  68. };
  69.  
  70. typedef struct VDXHWNDStruct *VDXHWND;
  71. typedef struct VDXBITMAPINFOHEADERStruct {
  72.     enum { kCompressionRGB = 0 };
  73.     uint32            mSize;
  74.     sint32            mWidth;
  75.     sint32            mHeight;
  76.     uint16            mPlanes;
  77.     uint32            mCompression;
  78.     uint32            mSizeImage;
  79.     sint32            mXPelsPerMeter;
  80.     sint32            mYPelsPerMeter;
  81.     uint32            mClrUsed;
  82.     uint32            mClrImportant;
  83. } VDXBITMAPINFOHEADER;
  84.  
  85. typedef struct VDXWAVEFORMATEXStruct {
  86.     enum { kFormatPCM = 1 };
  87.     uint16            mFormatTag;
  88.     uint16            mChannels;
  89.     uint32            mSamplesPerSec;
  90.     uint32            mAvgBytesPerSec;
  91.     uint16            mBlockAlign;
  92.     uint16            mBitsPerSample;
  93.     uint16            mExtraSize;
  94. } VDXWAVEFORMATEX;
  95.  
  96. #define VDXMAKEFOURCC(a, b, c, d) ((uint32)(uint8)(d) + ((uint32)(uint8)(c) << 8) + ((uint32)(uint8)(b) << 16) + ((uint32)(uint8)(a) << 24))
  97.  
  98. class IVDXUnknown {
  99. public:
  100.     enum { kIID = VDXMAKEFOURCC('X', 'u', 'n', 'k') };
  101.     virtual int VDXAPIENTRY AddRef() = 0;
  102.     virtual int VDXAPIENTRY Release() = 0;
  103.     virtual void *VDXAPIENTRY AsInterface(uint32 iid) = 0;
  104. };
  105.  
  106. struct VDXStreamSourceInfo {
  107.     VDXFraction        mSampleRate;
  108.     sint64            mSampleCount;
  109.     VDXFraction        mPixelAspectRatio;
  110. };
  111.  
  112. class IVDXStreamSource : public IVDXUnknown {
  113. public:
  114.     enum { kIID = VDXMAKEFOURCC('X', 's', 't', 's') };
  115.  
  116.     virtual void                VDXAPIENTRY GetStreamSourceInfo(VDXStreamSourceInfo&) = 0;
  117.  
  118.     virtual bool                VDXAPIENTRY Read(sint64 lStart, uint32 lCount, void *lpBuffer, uint32 cbBuffer, uint32 *lBytesRead, uint32 *lSamplesRead) = 0;
  119.  
  120.     virtual const void *        VDXAPIENTRY GetDirectFormat() = 0;
  121.     virtual int                    VDXAPIENTRY GetDirectFormatLen() = 0;
  122.  
  123.     enum ErrorMode {
  124.         kErrorModeReportAll = 0,
  125.         kErrorModeConceal,
  126.         kErrorModeDecodeAnyway,
  127.         kErrorModeCount
  128.     };
  129.  
  130.     virtual ErrorMode            VDXAPIENTRY GetDecodeErrorMode() = 0;
  131.     virtual void                VDXAPIENTRY SetDecodeErrorMode(ErrorMode mode) = 0;
  132.     virtual bool                VDXAPIENTRY IsDecodeErrorModeSupported(ErrorMode mode) = 0;
  133.  
  134.     virtual bool                VDXAPIENTRY IsVBR() = 0;
  135.     virtual sint64                VDXAPIENTRY TimeToPositionVBR(sint64 us) = 0;
  136.     virtual sint64                VDXAPIENTRY PositionToTimeVBR(sint64 samples) = 0;
  137. };
  138.  
  139. class IVDXVideoDecoderModel : public IVDXUnknown {
  140. public:
  141.     enum { kIID = VDXMAKEFOURCC('X', 'v', 'd', 'm') };
  142.  
  143.     virtual void                VDXAPIENTRY Reset() = 0;
  144.     virtual void                VDXAPIENTRY SetDesiredFrame(sint64 frame_num) = 0;
  145.     virtual sint64                VDXAPIENTRY GetNextRequiredSample(bool& is_preroll) = 0;
  146.     virtual int                    VDXAPIENTRY GetRequiredCount() = 0;
  147. };
  148.  
  149. class IVDXVideoDecoder : public IVDXUnknown {
  150. public:
  151.     enum { kIID = VDXMAKEFOURCC('X', 'v', 'd', 'e') };
  152.  
  153.     virtual const void *        VDXAPIENTRY DecodeFrame(const void *inputBuffer, uint32 data_len, bool is_preroll, sint64 sampleNumber, sint64 targetFrame) = 0;
  154.     virtual uint32                VDXAPIENTRY GetDecodePadding() = 0;
  155.     virtual void                VDXAPIENTRY Reset() = 0;
  156.     virtual    bool                VDXAPIENTRY IsFrameBufferValid() = 0;
  157.     virtual const VDXPixmap&    VDXAPIENTRY GetFrameBuffer() = 0;
  158.     virtual bool                VDXAPIENTRY SetTargetFormat(int format, bool useDIBAlignment) = 0;
  159.     virtual bool                VDXAPIENTRY SetDecompressedFormat(const VDXBITMAPINFOHEADER *pbih) = 0;
  160.  
  161.     virtual bool                VDXAPIENTRY IsDecodable(sint64 sample_num) = 0;
  162.     virtual const void *        VDXAPIENTRY GetFrameBufferBase() = 0;
  163. };
  164.  
  165. enum VDXVideoFrameType {
  166.     kVDXVFT_Independent,
  167.     kVDXVFT_Predicted,
  168.     kVDXVFT_Bidirectional,
  169.     kVDXVFT_Null,
  170. };
  171.  
  172. struct VDXVideoFrameInfo {
  173.     char    mTypeChar;
  174.     uint8    mFrameType;
  175.     sint64    mBytePosition;
  176. };
  177.  
  178. struct VDXVideoSourceInfo {
  179.     enum DecoderModel {
  180.         kDecoderModelCustom,    ///< A custom decoder model is provided.
  181.         kDecoderModelDefaultIP    ///< Use the default I/P decoder model.
  182.     };
  183.  
  184.     enum Flags {
  185.         kFlagNone            = 0,
  186.         kFlagKeyframeOnly    = 0x00000001,
  187.         kFlagAll            = 0xFFFFFFFF
  188.     };
  189.  
  190. public:
  191.     uint32    mFlags;
  192.     uint32    mWidth;
  193.     uint32    mHeight;
  194.     uint8    mDecoderModel;
  195.     uint8    unused[3];
  196. };
  197.  
  198. class IVDXVideoSource : public IVDXUnknown {
  199. public:
  200.     enum { kIID = VDXMAKEFOURCC('X', 'v', 'd', 's') };
  201.  
  202.     virtual void    VDXAPIENTRY GetVideoSourceInfo(VDXVideoSourceInfo& info) = 0;
  203.  
  204.     virtual bool    VDXAPIENTRY CreateVideoDecoderModel(IVDXVideoDecoderModel **) = 0;
  205.     virtual bool    VDXAPIENTRY CreateVideoDecoder(IVDXVideoDecoder **) = 0;
  206.  
  207.     virtual void    VDXAPIENTRY GetSampleInfo(sint64 sample_num, VDXVideoFrameInfo& frameInfo) = 0;
  208.  
  209.     virtual bool    VDXAPIENTRY IsKey(sint64 sample_num) = 0;
  210.  
  211.     virtual sint64    VDXAPIENTRY GetFrameNumberForSample(sint64 sample_num) = 0;
  212.     virtual sint64    VDXAPIENTRY GetSampleNumberForFrame(sint64 frame_num) = 0;
  213.     virtual sint64    VDXAPIENTRY GetRealFrame(sint64 frame_num) = 0;
  214.  
  215.     virtual sint64    VDXAPIENTRY GetSampleBytePosition(sint64 sample_num) = 0;
  216. };
  217.  
  218. struct VDXAudioSourceInfo {
  219. public:
  220.     uint32    mFlags;
  221. };
  222.  
  223. class IVDXAudioSource : public IVDXUnknown {
  224. public:
  225.     enum { kIID = VDXMAKEFOURCC('X', 'a', 'd', 's') };
  226.  
  227.     virtual void VDXAPIENTRY GetAudioSourceInfo(VDXAudioSourceInfo& info) = 0;
  228. };
  229.  
  230. class IVDXInputOptions : public IVDXUnknown {
  231. public:
  232.     enum { kIID = VDXMAKEFOURCC('X', 'i', 'o', 'p') };
  233.  
  234.     virtual uint32        VDXAPIENTRY Write(void *buf, uint32 buflen) = 0;
  235. };
  236.  
  237. class IVDXInputFile : public IVDXUnknown {
  238. public:
  239.     enum { kIID = VDXMAKEFOURCC('X', 'i', 'f', 'l') };
  240.  
  241.     virtual bool    VDXAPIENTRY PromptForOptions(VDXHWND, IVDXInputOptions **ppOptions) = 0;
  242.     virtual bool    VDXAPIENTRY CreateOptions(const void *buf, uint32 len, IVDXInputOptions **ppOptions) = 0;
  243.  
  244.     virtual void    VDXAPIENTRY Init(const wchar_t *path, IVDXInputOptions *options) = 0;
  245.     virtual bool    VDXAPIENTRY Append(const wchar_t *path) = 0;
  246.  
  247.     virtual void    VDXAPIENTRY DisplayInfo(VDXHWND hwndParent) = 0;
  248.  
  249.     virtual bool    VDXAPIENTRY GetVideoSource(int index, IVDXVideoSource **ppVS) = 0;
  250.     virtual bool    VDXAPIENTRY GetAudioSource(int index, IVDXAudioSource **ppAS) = 0;
  251. };
  252.  
  253. ///////////////////////////////////////////////////////////////////////////////
  254. // IVDXInputFileDriver
  255. //
  256. class IVDXInputFileDriver : public IVDXUnknown {
  257. public:
  258.     enum { kIID = VDXMAKEFOURCC('X', 'i', 'f', 'd') };
  259.  
  260.     virtual int        VDXAPIENTRY DetectBySignature(const void *pHeader, sint32 nHeaderSize, const void *pFooter, sint32 nFooterSize, sint64 nFileSize) = 0;
  261.     virtual bool    VDXAPIENTRY CreateInputFile(uint32 flags, IVDXInputFile **ppFile) = 0;
  262. };
  263.  
  264. struct VDInputDriverContext {
  265.     uint32    mAPIVersion;
  266.     IVDPluginCallbacks *mpCallbacks;
  267. };
  268.  
  269. typedef bool (VDXAPIENTRY *VDInputDriverCreateProc)(const VDInputDriverContext *pContext, IVDXInputFileDriver **);
  270.  
  271. struct VDInputDriverDefinition {
  272.     enum {
  273.         kFlagNone                = 0x00000000,
  274.         kFlagSupportsVideo        = 0x00000001,
  275.         kFlagSupportsAudio        = 0x00000002,
  276.         kFlagCustomSignature    = 0x00010000,
  277.         kFlagAll                = 0xFFFFFFFF
  278.     };
  279.     uint32        mSize;                // size of this structure in bytes
  280.     uint32        mFlags;
  281.     sint32        mPriority;
  282.     uint32        mSignatureLength;
  283.     const void *mpSignature;
  284.     const wchar_t *mpFilenameDetectPattern;
  285.     const wchar_t *mpFilenamePattern;
  286.     const wchar_t *mpDriverTagName;
  287.  
  288.     VDInputDriverCreateProc            mpCreate;
  289. };
  290.  
  291. enum {
  292.     // V1 (1.7.4.28204): Initial version
  293.     // V2 (1.7.5): Default I/P frame model fixed.
  294.     kVDPlugin_InputDriverAPIVersion = 2
  295. };
  296.  
  297. #endif
  298.